/*
 * Copyright 2010-2012 Susanta Tewari. <freecode4susant@users.sourceforge.net>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package bd.org.apache.commons.math.linear;

import bd.org.apache.commons.math.exception.DimensionMismatchException;
import bd.org.apache.commons.math.exception.MathIllegalStateException;
import bd.org.apache.commons.math.exception.NoDataException;
import bd.org.apache.commons.math.exception.NullArgumentException;
import bd.org.apache.commons.math.exception.util.LocalizedFormats;
import bd.org.apache.commons.math.util.MathUtils;

import java.io.Serializable;

/**
 * Implementation of {@link RealMatrix} using a {@code double[][]} array to
 * store entries.
 *
 * @version $Id: Array2DRowRealMatrix.java 1296537 2012-03-03 00:45:19Z sebb $
 */
public class Array2DRowRealMatrix extends AbstractRealMatrix implements Serializable {

    /**
     * Serializable version identifier.
     */
    private static final long serialVersionUID = -1067294169172445528L;

    /**
     * Entries of the matrix.
     */
    private double data[][];

    /**
     * Creates a matrix with no data
     */
    public Array2DRowRealMatrix() {}

    /**
     * Create a new (column) RealMatrix using {@code v} as the
     * data for the unique column of the created matrix.
     * The input array is copied.
     *
     * @param v Column vector holding data for new matrix.
     */
    public Array2DRowRealMatrix(final double[] v) {

        final int nRows = v.length;

        data = new double[nRows][1];

        for (int row = 0; row < nRows; row++) {

            data[row][0] = v[row];
        }
    }

    /**
     * Create a new {@code RealMatrix} using the input array as the underlying
     * data array.
     * <p>The input array is copied, not referenced. This constructor has
     * the same effect as calling {@link #Array2DRowRealMatrix(double[][], boolean)}
     * with the second argument set to {@code true}.</p>
     *
     * @param d Data for the new matrix.
     * @throws DimensionMismatchException if {@code d} is not rectangular.
     * @throws NoDataException if {@code d} row or colum dimension is zero.
     * @throws NullArgumentException if {@code d} is {@code null}.
     * @see #Array2DRowRealMatrix(double[][], boolean)
     */
    public Array2DRowRealMatrix(final double[][] d)
            throws DimensionMismatchException, NoDataException, NullArgumentException {

        copyIn(d);
    }

    /**
     * Create a new RealMatrix using the input array as the underlying
     * data array.
     * If an array is built specially in order to be embedded in a
     * RealMatrix and not used directly, the {@code copyArray} may be
     * set to {@code false}. This will prevent the copying and improve
     * performance as no new array will be built and no data will be copied.
     *
     * @param d Data for new matrix.
     * @param copyArray if {@code true}, the input array will be copied,
     * otherwise it will be referenced.
     * @see #Array2DRowRealMatrix(double[][])
     */
    public Array2DRowRealMatrix(final double[][] d, final boolean copyArray) {

        if (copyArray) {
            copyIn(d);
        } else {

            if (d == null) {
                throw new NullArgumentException();
            }

            final int nRows = d.length;

            if (nRows == 0) {
                throw new NoDataException(LocalizedFormats.AT_LEAST_ONE_ROW);
            }

            final int nCols = d[0].length;

            if (nCols == 0) {
                throw new NoDataException(LocalizedFormats.AT_LEAST_ONE_COLUMN);
            }

            for (int r = 1; r < nRows; r++) {

                if (d[r].length != nCols) {
                    throw new DimensionMismatchException(d[r].length, nCols);
                }
            }

            data = d;
        }
    }

    /**
     * Create a new RealMatrix with the supplied row and column dimensions.
     *
     * @param rowDimension Number of rows in the new matrix.
     * @param columnDimension Number of columns in the new matrix.
     */
    public Array2DRowRealMatrix(final int rowDimension, final int columnDimension) {

        super(rowDimension, columnDimension);

        data = new double[rowDimension][columnDimension];
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public RealMatrix createMatrix(final int rowDimension, final int columnDimension) {

        return new Array2DRowRealMatrix(rowDimension, columnDimension);
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public RealMatrix copy() {

        return new Array2DRowRealMatrix(copyOut(), false);
    }


    /**
     * Compute the sum of this matrix with {@code m}.
     *
     * @param m Matrix to be added.
     * @return {@code this} + m.
     */
    public Array2DRowRealMatrix add(final Array2DRowRealMatrix m) {

        // Safety check.
        MatrixUtils.checkAdditionCompatible(this, m);

        final int        rowCount    = getRowDimension();
        final int        columnCount = getColumnDimension();
        final double[][] outData     = new double[rowCount][columnCount];

        for (int row = 0; row < rowCount; row++) {

            final double[] dataRow    = data[row];
            final double[] mRow       = m.data[row];
            final double[] outDataRow = outData[row];

            for (int col = 0; col < columnCount; col++) {

                outDataRow[col] = dataRow[col] + mRow[col];
            }
        }

        return new Array2DRowRealMatrix(outData, false);
    }


    /**
     * Subtract {@code m} from this matrix.
     *
     * @param m Matrix to be subtracted.
     * @return {@code this} - m.
     */
    public Array2DRowRealMatrix subtract(final Array2DRowRealMatrix m) {

        // Safety check.
        MatrixUtils.checkSubtractionCompatible(this, m);

        final int        rowCount    = getRowDimension();
        final int        columnCount = getColumnDimension();
        final double[][] outData     = new double[rowCount][columnCount];

        for (int row = 0; row < rowCount; row++) {

            final double[] dataRow    = data[row];
            final double[] mRow       = m.data[row];
            final double[] outDataRow = outData[row];

            for (int col = 0; col < columnCount; col++) {

                outDataRow[col] = dataRow[col] - mRow[col];
            }
        }

        return new Array2DRowRealMatrix(outData, false);
    }


    /**
     * Postmultiplying this matrix by {@code m}.
     *
     * @param m Matrix to postmultiply by.
     * @return {@code this} * m.
     * matrix is not equal to the number of rows of {@code m}.
     */
    public Array2DRowRealMatrix multiply(final Array2DRowRealMatrix m) {

        // Safety check.
        MatrixUtils.checkMultiplicationCompatible(this, m);

        final int        nRows   = this.getRowDimension();
        final int        nCols   = m.getColumnDimension();
        final int        nSum    = this.getColumnDimension();

        final double[][] outData = new double[nRows][nCols];

        // Will hold a column of "m".
        final double[]   mCol  = new double[nSum];
        final double[][] mData = m.data;

        // Multiply.
        for (int col = 0; col < nCols; col++) {

            // Copy all elements of column "col" of "m" so that
            // will be in contiguous memory.
            for (int mRow = 0; mRow < nSum; mRow++) {

                mCol[mRow] = mData[mRow][col];
            }

            for (int row = 0; row < nRows; row++) {

                final double[] dataRow = data[row];
                double         sum     = 0;

                for (int i = 0; i < nSum; i++) {

                    sum += dataRow[i] * mCol[i];
                }

                outData[row][col] = sum;
            }
        }

        return new Array2DRowRealMatrix(outData, false);
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double[][] getData() {

        return copyOut();
    }


    /**
     * Get a reference to the underlying data array.
     *
     * @return 2-dimensional array of entries.
     */
    public double[][] getDataRef() {

        return data;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public void setSubMatrix(final double[][] subMatrix, final int row, final int column) {

        if (data == null) {

            if (row > 0) {

                throw new MathIllegalStateException(
                    LocalizedFormats.FIRST_ROWS_NOT_INITIALIZED_YET, row);
            }

            if (column > 0) {

                throw new MathIllegalStateException(
                    LocalizedFormats.FIRST_COLUMNS_NOT_INITIALIZED_YET, column);
            }

            MathUtils.checkNotNull(subMatrix);

            final int nRows = subMatrix.length;

            if (nRows == 0) {
                throw new NoDataException(LocalizedFormats.AT_LEAST_ONE_ROW);
            }

            final int nCols = subMatrix[0].length;

            if (nCols == 0) {
                throw new NoDataException(LocalizedFormats.AT_LEAST_ONE_COLUMN);
            }

            data = new double[subMatrix.length][nCols];

            for (int i = 0; i < data.length; ++i) {

                if (subMatrix[i].length != nCols) {
                    throw new DimensionMismatchException(subMatrix[i].length, nCols);
                }

                System.arraycopy(subMatrix[i], 0, data[i + row], column, nCols);
            }

        } else {
            super.setSubMatrix(subMatrix, row, column);
        }

    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double getEntry(final int row, final int column) {

        MatrixUtils.checkMatrixIndex(this, row, column);

        return data[row][column];
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public void setEntry(final int row, final int column, final double value) {

        MatrixUtils.checkMatrixIndex(this, row, column);

        data[row][column] = value;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public void addToEntry(final int row, final int column, final double increment) {

        MatrixUtils.checkMatrixIndex(this, row, column);

        data[row][column] += increment;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public void multiplyEntry(final int row, final int column, final double factor) {

        MatrixUtils.checkMatrixIndex(this, row, column);

        data[row][column] *= factor;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public int getRowDimension() {

        return (data == null)
               ? 0
               : data.length;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public int getColumnDimension() {

        return ((data == null) || (data[0] == null))
               ? 0
               : data[0].length;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double[] operate(final double[] v) {

        final int nRows = this.getRowDimension();
        final int nCols = this.getColumnDimension();

        if (v.length != nCols) {
            throw new DimensionMismatchException(v.length, nCols);
        }

        final double[] out = new double[nRows];

        for (int row = 0; row < nRows; row++) {

            final double[] dataRow = data[row];
            double         sum     = 0;

            for (int i = 0; i < nCols; i++) {

                sum += dataRow[i] * v[i];
            }

            out[row] = sum;
        }

        return out;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double[] preMultiply(final double[] v) {

        final int nRows = getRowDimension();
        final int nCols = getColumnDimension();

        if (v.length != nRows) {
            throw new DimensionMismatchException(v.length, nRows);
        }

        final double[] out = new double[nCols];

        for (int col = 0; col < nCols; ++col) {

            double sum = 0;

            for (int i = 0; i < nRows; ++i) {

                sum += data[i][col] * v[i];
            }

            out[col] = sum;
        }

        return out;

    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double walkInRowOrder(final RealMatrixChangingVisitor visitor) {

        final int rows    = getRowDimension();
        final int columns = getColumnDimension();

        visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);

        for (int i = 0; i < rows; ++i) {

            final double[] rowI = data[i];

            for (int j = 0; j < columns; ++j) {

                rowI[j] = visitor.visit(i, j, rowI[j]);
            }
        }

        return visitor.end();
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double walkInRowOrder(final RealMatrixPreservingVisitor visitor) {

        final int rows    = getRowDimension();
        final int columns = getColumnDimension();

        visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);

        for (int i = 0; i < rows; ++i) {

            final double[] rowI = data[i];

            for (int j = 0; j < columns; ++j) {

                visitor.visit(i, j, rowI[j]);
            }
        }

        return visitor.end();
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double walkInRowOrder(final RealMatrixChangingVisitor visitor, final int startRow,
                                 final int endRow, final int startColumn, final int endColumn) {

        MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
        visitor.start(getRowDimension(), getColumnDimension(), startRow, endRow, startColumn,
                      endColumn);

        for (int i = startRow; i <= endRow; ++i) {

            final double[] rowI = data[i];

            for (int j = startColumn; j <= endColumn; ++j) {

                rowI[j] = visitor.visit(i, j, rowI[j]);
            }
        }

        return visitor.end();
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double walkInRowOrder(final RealMatrixPreservingVisitor visitor, final int startRow,
                                 final int endRow, final int startColumn, final int endColumn) {

        MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
        visitor.start(getRowDimension(), getColumnDimension(), startRow, endRow, startColumn,
                      endColumn);

        for (int i = startRow; i <= endRow; ++i) {

            final double[] rowI = data[i];

            for (int j = startColumn; j <= endColumn; ++j) {

                visitor.visit(i, j, rowI[j]);
            }
        }

        return visitor.end();
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double walkInColumnOrder(final RealMatrixChangingVisitor visitor) {

        final int rows    = getRowDimension();
        final int columns = getColumnDimension();

        visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);

        for (int j = 0; j < columns; ++j) {

            for (int i = 0; i < rows; ++i) {

                final double[] rowI = data[i];

                rowI[j] = visitor.visit(i, j, rowI[j]);
            }
        }

        return visitor.end();
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double walkInColumnOrder(final RealMatrixPreservingVisitor visitor) {

        final int rows    = getRowDimension();
        final int columns = getColumnDimension();

        visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);

        for (int j = 0; j < columns; ++j) {

            for (int i = 0; i < rows; ++i) {

                visitor.visit(i, j, data[i][j]);
            }
        }

        return visitor.end();
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double walkInColumnOrder(final RealMatrixChangingVisitor visitor, final int startRow,
                                    final int endRow, final int startColumn, final int endColumn) {

        MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
        visitor.start(getRowDimension(), getColumnDimension(), startRow, endRow, startColumn,
                      endColumn);

        for (int j = startColumn; j <= endColumn; ++j) {

            for (int i = startRow; i <= endRow; ++i) {

                final double[] rowI = data[i];

                rowI[j] = visitor.visit(i, j, rowI[j]);
            }
        }

        return visitor.end();
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double walkInColumnOrder(final RealMatrixPreservingVisitor visitor, final int startRow,
                                    final int endRow, final int startColumn, final int endColumn) {

        MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
        visitor.start(getRowDimension(), getColumnDimension(), startRow, endRow, startColumn,
                      endColumn);

        for (int j = startColumn; j <= endColumn; ++j) {

            for (int i = startRow; i <= endRow; ++i) {

                visitor.visit(i, j, data[i][j]);
            }
        }

        return visitor.end();
    }


    /**
     * Get a fresh copy of the underlying data array.
     *
     * @return a copy of the underlying data array.
     */
    private double[][] copyOut() {

        final int        nRows = this.getRowDimension();
        final double[][] out   = new double[nRows][this.getColumnDimension()];

        // can't copy 2-d array in one shot, otherwise get row references
        for (int i = 0; i < nRows; i++) {

            System.arraycopy(data[i], 0, out[i], 0, data[i].length);
        }

        return out;
    }


    /**
     * Replace data with a fresh copy of the input array.
     *
     * @param in Data to copy.
     * @throws NoDataException if the input array is empty.
     * @throws DimensionMismatchException if the input array is not rectangular.
     * @throws NullArgumentException if
     * the input array is {@code null}.
     */
    private void copyIn(final double[][] in)
            throws DimensionMismatchException, NoDataException, NullArgumentException {

        setSubMatrix(in, 0, 0);
    }
}
